// Copyright Up and Running

var acctModule = require("../../server/account");

describe("An Account Manager", function () {

    beforeEach(function() {
        this.accountManager = acctModule.accountManager();
    });

    afterEach(function() {
        this.accountManager = null;
    });


    it("should return an account object when it is asked for", function () {
        var account = this.accountManager.getAccount(123);
        expect(account.accountKey).toBe(123);
    });

    it("should track accounts and allow their values to change and still maintain their reference", function() {
        var account = this.accountManager.getAccount(123);
        expect(account.accountKey).toBe(123);
        account.foo = 'bar';
        var new_account = this.accountManager.getAccount(123);
        expect(new_account.foo).toBe('bar');
    });

    it("can track multiple accounts and fetch the appropriate one when needed", function () {
        var account1 = this.accountManager.getAccount(123);
        var account2 = this.accountManager.getAccount(124);

        expect(account1.accountKey).toBe(123);
        expect(account2.accountKey).toBe(124);
    });
});

describe("An Account", function () {

    var key = 123;

    beforeEach(function() {
        var am = acctModule.accountManager();
        this.account = am.getAccount(key);
    });

    afterEach(function() {
        this.account = null;
    });

    it("should initially have 0 devices", function() {
        expect(this.account.registeredDeviceCount()).toEqual(0);
    });

    it("should be able to generate a device GUID", function() {
        var guid = this.account.generateDeviceUUID();

        expect(guid).toBeDefined();
        expect(guid).toBeTruthy();
    });

    it("UUIDs generated should be random and unique", function () {
        var uuids = Array();
        for (i = 0; i < 1000; i++) {
            uuids.push(this.account.generateDeviceUUID());
        }
        expect(uuids.length).toEqual(1000);

        // assign a unique method to the array
        uuids.unique = function() {
            var o = {}, i, l = this.length, r = [];
            for(i=0; i<l;i+=1) o[this[i]] = this[i];
            for(i in o) r.push(o[i]);
            return r;
        };

        // process to get the unique uuids
        unique_uuids = uuids.unique();

        // make sure they're the same
        expect(unique_uuids.length).toEqual(1000);

        // lets purposefully add a duplicate UUID
        var id = uuids[uuids.length - 1];
        uuids.push(id);

        expect(uuids.length).toEqual(1001);

        // then lets make sure it gets eliminated
        unique_uuids = uuids.unique();
        expect(unique_uuids.length).toEqual(1000);


    });

    it("can register a device object without an ID",function() {
        var device = {
            ip: '127.0.0.1',
            extension: 100,
            request: {},
            response: {}
        }

        this.account.registerDevice(device);

        var keys = Object.keys(this.account.devices);

        expect(keys.length).toEqual(1);

        var uuid = keys[0];

        expect(this.account.devices[uuid]).toBeDefined();

    });

    it("can register a device object with an ID", function() {
        var uuid = this.account.generateDeviceUUID();
        var device = {
            uuid: uuid,
            ip: '127.0.0.1',
            extension: 100,
            request: {},
            response: {}
        }

        this.account.registerDevice(device);

        expect(this.account.registeredDeviceCount()).toEqual(1);
        expect(this.account.devices[uuid].uuid).toEqual(uuid);

    });

    it("can have a device register a notification to other devices", function() {
        var device1 = {
            uuid: this.account.generateDeviceUUID(),
            ip: '127.0.0.1',
            extension: 100,
            request: {},
            response: { send: function(msg) {this.msg = msg;}}
        };

        var device2 = {
            uuid: this.account.generateDeviceUUID(),
            ip: '127.0.0.1',
            extension: 101,
            request: {},
            response: { send: function(msg) {this.msg = msg;}}
        };

        var notifyingDevice = {
            uuid: this.account.generateDeviceUUID(),
            ip: '127.0.0.1',
            extension: 102,
            request: {},
            response: { send: function(msg) {this.msg = msg;}}
        };


        this.account.registerDevice(device1);
        this.account.registerDevice(device2);
        this.account.registerDevice(notifyingDevice);

        expect(this.account.registeredDeviceCount()).toEqual(3);

        this.account.notifyDevices(notifyingDevice,{alert: '911 called'});

        for (key in this.account.devices) {

            var device = this.account.devices[key];

            if (device.uuid == notifyingDevice.uuid) {
                expect(device.response.msg).toBeUndefined();
            } else {
                expect(device.response.msg).toBeDefined();
                expect(device.response.msg).toBeTruthy();
            }
        }

    });

    it("can support a limited number of device registrations",function() {
        var device1 = {
            uuid: this.account.generateDeviceUUID(),
            ip: '127.0.0.1',
            extension: 100,
            request: {},
            response: { send: function(msg) {this.msg = msg;}}
        };

        var device2 = {
            uuid: this.account.generateDeviceUUID(),
            ip: '127.0.0.1',
            extension: 101,
            request: {},
            response: { send: function(msg) {this.msg = msg;}}
        };

        expect(this.account.deviceLimit).toBeNull();

        this.account.deviceLimit = 1;
        expect(this.account.deviceLimit).toEqual(1);

        var result1 = this.account.registerDevice(device1);
        expect(result1).toBe(true);
        var result2 = this.account.registerDevice(device2);
        expect(result2).toBe(false);
    });

});